package com.cskaoyan.service;

import com.cskaoyan.bean.bo.*;
import com.cskaoyan.bean.entity.*;
import com.cskaoyan.bean.vo.*;
import com.cskaoyan.mapper.*;
import com.cskaoyan.utils.Constant;
import org.apache.shiro.session.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

/**
 * @author XuBang
 * @TODO:
 * @date 2021/10/22$
 * @trainOfthought:
 */
@Service
public class WxCartServiceImpl implements WxCartService {

    @Autowired
    GoodsMapper goodsMapper;

    @Autowired
    GoodsProductMapper goodsProductMapper;

    @Autowired
    CartMapper cartMapper;

    @Autowired
    CouponMapper couponMapper;

    @Autowired
    CouponUserMapper couponUserMapper;

    @Autowired
    OrderMapper orderMapper;

    @Autowired
    AddressMapper addressMapper;

    @Autowired
    OrderGoodsMapper orderGoodsMapper;

    /**
     * > 根据goodsId,在market_goods表中查询，黑圈信息；
     * >
     * > 根据produce_id，在market_goods_product表中，查询：红圈信息；
     * >
     * > number是请求参数传入；
     * >
     * > id默认null;
     * >
     * > user_idmarket_user中，id，为1
     * <p>
     * > 根据基本信息查询信息，并将信息插入到market_cart表格中
     *
     * @param注：为了使用typeHandler，对Cart的数据结构进行改变：cart.setSpecifications(goodsProduct.getSpecifications())
     */
    @Override
    public void addCart(CartAddJsonBo cartAddJsonBo, Integer id) {
        Integer goodsId = cartAddJsonBo.getGoodsId();
        Integer productId = cartAddJsonBo.getProductId();
        Integer number = cartAddJsonBo.getNumber();
        //0.逆向工程获取基本工具
        //1.根据goodsId,在market_goods表中查询，黑圈信息；
        Goods goods = goodsMapper.selectByPrimaryKey(goodsId);
        //2.根据produce_id，在market_goods_product表中，查询：红圈信息；
        GoodsProduct goodsProduct = goodsProductMapper.selectByPrimaryKey(productId);
        //3.根据基本信息查询信息，并将信息插入到market_cart表格中
        //typeHandler:cart.setSpecifications("需要使用typeHandler处理");
        //具体处理：List<String>--->String--->varchar（这里仅仅涉及输入映射）

        //修改：根据goodsId和productId，可以唯一确定market_cart中的一条数据

        //修改：解决同一商品不能合并的问题:根据goodsId在market-cart中查询出对饮的productId
        CartExample example1 = new CartExample();
        CartExample.Criteria criteria1 = example1.createCriteria();
        criteria1.andGoodsIdEqualTo(goodsId);
        List<Cart> carts1 = cartMapper.selectByExample(example1);
        Integer productID=0;

        Cart cart = new Cart();
        if(carts1.size()!=0){
            productID=carts1.get(0).getProductId();

            if (productID == productId) {    //如果商品id-goodsId和产品id-productId，都对应，则update数量
                //判断条件设置
                CartExample example = new CartExample();
                CartExample.Criteria criteria = example.createCriteria();
                criteria.andGoodsIdEqualTo(goodsId);
                criteria.andProductIdEqualTo(productId);
                //先查询
                List<Cart> carts = cartMapper.selectByExample(example);  //根据goodsId和productId，查询出carts；一般只有一个，取出number
                Integer number1 = carts.get(0).getNumber();
                //后修改
                Cart cart1 = new Cart();
                cart1.setNumber(number1 + number);
                cartMapper.updateByExampleSelective(cart1, example);  //更改number
            }
        }
        else {  //否则，该数据不存在；执行插入操作
            cart.setId(null);
            cart.setUserId(id);
            cart.setGoodsId(goodsId);
            cart.setGoodsSn(goods.getGoodsSn());
            cart.setGoodsName(goods.getName());
            cart.setProductId(productId);
            cart.setPrice(goodsProduct.getPrice());
            cart.setNumber(number);
            cart.setSpecifications(goodsProduct.getSpecifications());
            cart.setChecked(0);
            cart.setPicUrl(goodsProduct.getUrl());
            cart.setAddTime(goodsProduct.getAddTime());
            cart.setUpdateTime(goodsProduct.getUpdateTime());
            cart.setDeleted(goodsProduct.getDeleted());
            cartMapper.insertSelective(cart);
        }
    }

    /**
     * 根据goodsId和productId,确定购物车market_cart中对应的数据，使用number进行更改
     *
     */
    @Override
    public void updateCart(CartUpdateJsonBo cartUpdateJsonBo) {
        Integer goodsId = cartUpdateJsonBo.getGoodsId();
        Integer productId = cartUpdateJsonBo.getProductId();
        Integer number = cartUpdateJsonBo.getNumber();

        //设置条件
        CartExample example = new CartExample();
        CartExample.Criteria criteria = example.createCriteria();
        criteria.andGoodsIdEqualTo(goodsId);
        criteria.andProductIdEqualTo(productId);

        Cart cart1 = new Cart();
        cart1.setNumber(number);
        cartMapper.updateByExampleSelective(cart1, example);  //根据goodsId和productId,更改number
    }

    @Override
    public Integer fastaddCart(CartFastAddJsonBo cartFastAddJsonBo, Integer id) {
        //1.获取goodsId和productId，查询数据，将对应数据插入到购物车中；
        Integer goodsId = cartFastAddJsonBo.getGoodsId();
        Integer productId = cartFastAddJsonBo.getProductId();

        Goods goods = goodsMapper.selectByPrimaryKey(goodsId);
        GoodsProduct goodsProduct = goodsProductMapper.selectByPrimaryKey(productId);

        Cart cart = new Cart();

        cart.setId(null);
        cart.setUserId(id);
        cart.setGoodsId(goodsId);
        cart.setGoodsSn(goods.getGoodsSn());
        cart.setGoodsName(goods.getName());
        cart.setProductId(productId);
        cart.setPrice(goodsProduct.getPrice());
        cart.setNumber(cartFastAddJsonBo.getNumber());
        cart.setSpecifications(goodsProduct.getSpecifications());
        cart.setChecked(0);
        cart.setPicUrl(goodsProduct.getUrl());
        cart.setAddTime(goodsProduct.getAddTime());
        cart.setUpdateTime(goodsProduct.getUpdateTime());
        cart.setDeleted(goodsProduct.getDeleted());

        cartMapper.insert(cart);

        //2.查询market_cart，返回对应的id;用于响应
        CartExample example = new CartExample();
        CartExample.Criteria criteria = example.createCriteria();
        criteria.andGoodsIdEqualTo(goodsId);
        criteria.andProductIdEqualTo(productId);

        List<Cart> carts = cartMapper.selectByExample(example);
        Integer id1 = carts.get(0).getId();

        //注：操作和add雷同
        return id1;
    }

    @Override
    public CartIndexTransferVo indexCart(Integer id) {
        //1.根据用户id,market_cart查询对应的商品总数和总价格（计算）；--->封装到cartTotal对象中
        CartExample example = new CartExample();
        CartExample.Criteria criteria = example.createCriteria();
        criteria.andUserIdEqualTo(id);

        //传入example
        CartIndexTransferVo cartIndexTransferVo = transferFZ(example);
        return cartIndexTransferVo;
    }

    @Override
    public CartIndexTransferVo deleteCart(Integer id, ProductIds productIds) {
        //1.接收请求参数list,根据用户id，在market_cart表格中，删除productId对应的商品信息；
        List<Integer> productIds1 = productIds.getProductIds();

        for (Integer productId : productIds1) {
            CartExample example1 = new CartExample();    //需要每一次创建一个新的example规则设定；
            CartExample.Criteria criteria1 = example1.createCriteria();
            criteria1.andUserIdEqualTo(id);

            criteria1.andProductIdEqualTo(productId);
            cartMapper.deleteByExample(example1);   //根据userid和productid，进行删除对应的商品信息
        }

        CartExample example = new CartExample();
        CartExample.Criteria criteria = example.createCriteria();
        criteria.andUserIdEqualTo(id);

        //2.根据用户id，查询market_cart中，该用户对应的其他商品信息（可以直接复用index部分的东西了）
//        List<Cart> carts = cartMapper.selectByExample(example);   //根据用户id，查询market_cart中，该用户对应的其他商品信息
        CartIndexTransferVo cartIndexTransferVo = transferFZ(example);
        return cartIndexTransferVo;
    }

    @Override
    public CartIndexTransferVo checkedCart(Integer id, CartCheckedBo cartCheckedBo) {
        //1.根据用户id,在market_cart中，进而根据productId,修改传入的checked值；
        Integer productId = cartCheckedBo.getProductIds().get(0);    //获取productId
        Integer checked = cartCheckedBo.getIsChecked();     //获取checked状态码----------对该状态码进行更改：0/1
        CartExample example = new CartExample();
        CartExample.Criteria criteria = example.createCriteria();
        criteria.andUserIdEqualTo(id);
        criteria.andProductIdEqualTo(productId);

//        Boolean ischecked;    //这样传值不对；数据库那边接收的是0/1；而不是false;
//        if(checked==0){
//            ischecked=false;
//        }else {
//            ischecked=true;
//        }
        //分析：每一次点击，都是0和1的交换-----》进一步分析：点击前端页面，选中：发送1    数据库从0 改为1     取消：发送0   数据库从1改为0
//        if (checked==1){
//            checked=0;
//        }else if(checked==0){
//            checked=1;
//        }

        Cart cart = new Cart();
        cart.setChecked(checked);
        cartMapper.updateByExampleSelective(cart, example);   //根据productId，对状态码进行改变：0/1

        //2.根据用户id,productId,checked值，确定如下参数值：根据id,productId,
        // 查询出checked的值；再根据这三个值，确定如下参数具体的值
        // 将如下参数封装到CartTotalDTO实例中；
        //"goodsCount": 5,-----------------------购物车商品总数
        //"checkedGoodsCount": 4,-----------------购物车选中商品总数
        //"goodsAmount": 365,------------购物车商品总价
        //"checkedGoodsAmount": 236-------------购物车选中商品总价
        CartExample example1 = new CartExample();
        CartExample.Criteria criteria1 = example1.createCriteria();
        criteria1.andUserIdEqualTo(id);  //根据用户id
        List<Cart> carts = cartMapper.selectByExample(example1);

        Integer goodsCount = 0;
        Integer checkedGoodsCount = 0;
        Double goodsAmount = 0.0;
        Double checkedGoodsAmount = 0.0;
        for (Cart cart1 : carts) {
            if (cart1.getChecked() == 1) {    //购物车中，选中的商品信息------------这里有些问题：明明选中，但是就是没有统计；需要再一次debug，验证一下；
                checkedGoodsCount += cart1.getNumber();
                checkedGoodsAmount += cart1.getNumber() * cart1.getPrice().doubleValue();
            }
            //购物车中，所有商品信息
            goodsCount += cart1.getNumber();
            goodsAmount += cart1.getNumber() * cart1.getPrice().doubleValue();
        }
        CartTotalDTO cartTotalDTO = new CartTotalDTO();
        cartTotalDTO.setGoodsCount(goodsCount);
        cartTotalDTO.setGoodsAmount(goodsAmount);
        cartTotalDTO.setCheckedGoodsCount(checkedGoodsCount);
        cartTotalDTO.setGoodsAmount(checkedGoodsAmount);

        //3.根据用户id,查询market_cart中，所有的商品数（可以复用index中的代码，记得已经封装成可以直接使用的函数）
        // 将如下参数封装到CartListDTO实例对象中；
        ArrayList<CartListDTO> cartListDTOS = new ArrayList<>();
        for (Cart cart1 : carts) {
            CartListDTO cartListDTO = new CartListDTO();
            cartListDTO.setId(cart1.getId());
            cartListDTO.setUserId(cart1.getUserId());
            cartListDTO.setGoodsId(cart1.getGoodsId());
            cartListDTO.setGoodsSn(cart1.getGoodsSn());
            cartListDTO.setGoodsName(cart1.getGoodsName());
            cartListDTO.setProductId(cart1.getProductId());
            cartListDTO.setPrice(cart1.getPrice().doubleValue());
            cartListDTO.setNumber(cart1.getNumber());
            cartListDTO.setSpecifications(cart1.getSpecifications());  //cart内部进行转化，后续也需要typehandler处理
            cartListDTO.setChecked(cart1.getChecked());
            cartListDTO.setPicUrl(cart1.getPicUrl());

            SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            cartListDTO.setAddTime(pattern.format(cart1.getAddTime()));   //date---->string(此处的转化，如果有问题，需要进一步思考)
            cartListDTO.setUpdateTime(pattern.format(cart1.getUpdateTime()));

            cartListDTO.setDeleted(cart1.getDeleted());
            cartListDTOS.add(cartListDTO);
        }
        CartIndexTransferVo cartIndexTransferVo = new CartIndexTransferVo();
        cartIndexTransferVo.setCartTotal(cartTotalDTO);
        cartIndexTransferVo.setCartList(cartListDTOS);
        return cartIndexTransferVo;
    }

    @Override
    public WxCheckoutVO checkout(Integer userId, WxCartFastAddBo wxCartFastAddBo) {
        //根据userID 查address表
        Address address = cartMapper.selectUserInf(userId);

        //根据userID查cart表
        List<Carts> carts = cartMapper.selectCartInf(userId);
        //计算goods total price
        Double goodsTotalPrice = 0.0;
        for (Carts cart : carts) {
            Short number = cart.getNumber();
            Double price = cart.getPrice();
            goodsTotalPrice += number * price;
        }
        //商品总价格
        Double goodPrice = goodsTotalPrice;
        Constant.goodsPrice = goodPrice;
        Double couponPrice=0.0;
        WxCartGetCouponPriceAndLength coupon=null;
        Integer availableCouponLength=0;
        //查coupon表
        try {
            coupon = cartMapper.selectUserCoupon(wxCartFastAddBo.getCouponId());
            couponPrice = coupon.getCouponPrice();
            availableCouponLength = coupon.getAvailableCouponLength();
            //判断是否符合使用条件
            if (coupon.getMin() < goodsTotalPrice) {
                goodsTotalPrice -= couponPrice;
            }
        }catch (NullPointerException e){
            couponPrice=0.0;
            Constant.couponPrice = 0.0;
        }
        //优惠券价格
        Constant.couponPrice = couponPrice;

        //查运费表
        WxExpress express=null ;
        Double freight = 0.0;
        try {
            express = cartMapper.selectExpress();
            //运费

            //判断是否免运费
            if (goodsTotalPrice < express.getFreightMin()) {
                goodsTotalPrice += express.getFreightValue();
                freight = express.getFreightValue();
            }
        }catch (NullPointerException e){

        }

        Constant.freightPrice = freight;
        //实际结算价格
        Double actualPrice = goodsTotalPrice+freight;
        Constant.actualPrice = actualPrice;
        Constant.orderPrice = actualPrice;
        //封装
        WxCheckoutVO wxCheckoutVO = new WxCheckoutVO();
        wxCheckoutVO.setCheckedAddress(address);
        wxCheckoutVO.setCheckedGoodsList(carts);
        wxCheckoutVO.setGrouponRulesId(wxCartFastAddBo.getGrouponRulesId());
        wxCheckoutVO.setActualPrice(actualPrice);
        wxCheckoutVO.setOrderTotalPrice(actualPrice);
        wxCheckoutVO.setCartId(0);
        wxCheckoutVO.setUserCouponId(wxCartFastAddBo.getUserCouponId());
        wxCheckoutVO.setCouponId(wxCartFastAddBo.getCouponId());
        wxCheckoutVO.setGoodsTotalPrice(goodsTotalPrice);
        wxCheckoutVO.setAddressId(wxCartFastAddBo.getAddressId());
        wxCheckoutVO.setGrouponPrice(couponPrice);
        wxCheckoutVO.setAvailableCouponLength(availableCouponLength);
        wxCheckoutVO.setFreightPrice(freight);
        wxCheckoutVO.setCouponPrice(couponPrice);
        return wxCheckoutVO;
    }

    /**
     * @param id
     * @param cartCheckoutBo
     * @return 1.基本的参数
     * -3个： addressId\cartId\grouponRulesId：这三个值，按照接收时候的原值，返回
     * -5个： actualPrice=orderTotalPrice：最终价格    =  goodsTotalPrice（商品总价格）-couponPrice（优惠券价格）+freightPrice（运费价格）
     * actualPrice真实价格：在market_order中，不需要cart部分存储；直接响应，即可
     * orderTotalPrice订单价格：在market_order中，不需要cart部分存储；直接响应，即可
     * goodsTotalPrice商品总价格:根据userId,在mark_cart中，查询商品price和number,进行计算，获得总价格；
     * 根据用户id，在market_coupon_user中查询couponId,进而根据couponId在market_coupon中查询discount，也就是当下的couponPrice优惠券价格；
     * （需要自己结合market_coupon在market_coupon_user，自己先造一份数据）
     * 根据用户id，在market_order中查询freight_price，也就是现在的freightPrice;
     * <p>
     * -grouponPrice=0;grouponRulesId=0（仅仅知道是团购优惠和团购表的id;多次测试都是0；所以：暂时默认为0）--团购无用做，所以：默认0
     * -userCouponId:暂时默认为108；固定值------>也许是：优惠券ID   market_coupon_user表格中（可以先直接返回108）
     * 2.checkedAddress
     * 根据addressId，market_address表中，查询对应信息；
     * 3.checkedGoodsList
     * 根据userId,market_order_goods表中查询对应信息
     */
//    @Override
//    public CartCheckOutVo checkoutCart(Integer id, CartCheckoutBo cartCheckoutBo) {
//        //0.基本参数&全局参数的设置
//        CartExample example = new CartExample();
//        CartExample.Criteria criteria = example.createCriteria();
//        criteria.andUserIdEqualTo(id);   //设置条件：根据id进行CRUD
//
//        Integer goodsTotalPrice = 0;  //商品总价格****************************需要返回****************************
//        Integer number = 0;  //商品数量
//        Integer price = 0;
//
//        //1.根据userId,在mark_cart中，查询商品price和number,进行计算，获得总价格；（需要判断筛选出checked=1的购物车数据）
//        List<Cart> carts = cartMapper.selectByExample(example);
//        for (Cart cart : carts) {
//            if (cart.getChecked() == 1) {
//                price = cart.getPrice().intValue();
//                number = cart.getNumber();
//                goodsTotalPrice += price * number;
//            }
//        }
//
//        //2.根据用户id，在market_coupon_user中查询couponId,进而根据couponId在market_coupon中查询discount，也就是当下的couponPrice优惠券价格；
//        //改进&注意：（如果出现问题，此处必须是检查的地方）****************************请求参数中的userCouponId,在market_coupon_user中查询couponId,进而根据couponId在market_coupon中查询discount，也就是当下的couponPrice优惠券价格；
//        // (考虑到：根据用户id，查询出的couponId,不止一个)?????????????前端的couponId从哪里来？我这里是-1；
//        Integer userCouponId = cartCheckoutBo.getUserCouponId();
//        userCouponId+=5;
//
//        CouponUser couponUser = couponUserMapper.selectByPrimaryKey(userCouponId);  //根据请求参数中的userCouponId,在market_coupon_user中查询couponId
//        Integer couponID =couponUser.getCouponId()+1;    //????????需要和优惠券商量????????????????????????????????
//        Coupon coupon = couponMapper.selectByPrimaryKey(couponID);  //根据couponId在market_coupon中查询discount，也就是当下的couponPrice优惠券价格；
//        Integer couponPrice = 0;//*************************************优惠券价格，需要返回*******************************
//        couponPrice = coupon.getDiscount().intValue();
//
//
//        //3.根据用户id，在market_order中查询freight_price，也就是现在的freightPrice;?????????????????????????????稍微问题
//        //改进：根据addressId,在market_address中查询
//        Integer freightPrice = 0;     //先指定一个固定值
////        OrderExample orderExample1 = new OrderExample();
////        OrderExample.Criteria criteria3 = orderExample1.createCriteria();
////        criteria3.andUserIdEqualTo(id);
////        List<Order> orders1 = orderMapper.selectByExample(orderExample1);
//
//        //4.根据上述数据，计算出：actualPrice=orderTotalPrice
//        Integer actualPrice = 0;   //********************************************************************
//        Integer orderTotalPrice = 0;   //********************************************************************
//        actualPrice=goodsTotalPrice-couponPrice+freightPrice;
//        orderTotalPrice=actualPrice;
//
//        //5.根据addressId，market_address表中，查询对应信息；将查询数据封装到CartCheckOut001Vo中
//        Integer addressId = cartCheckoutBo.getAddressId();
////        addressId+=1;------------------addressId传入1
//        Address address = addressMapper.selectByPrimaryKey(addressId);   //查询信息
//        CartCheckOut001Vo cartCheckOut001Vo = new CartCheckOut001Vo();   //封装信息
//
//        cartCheckOut001Vo.setId(address.getId());
//        cartCheckOut001Vo.setName(address.getName());
//        cartCheckOut001Vo.setUserId(address.getUserId());
//        cartCheckOut001Vo.setProvince(address.getProvince());
//        cartCheckOut001Vo.setCity(address.getCity());
//        cartCheckOut001Vo.setCounty(address.getCounty());
//        cartCheckOut001Vo.setAddressDetail(address.getAddressDetail());
//        cartCheckOut001Vo.setAreaCode(address.getAreaCode());
//        cartCheckOut001Vo.setTel(address.getTel());
//        cartCheckOut001Vo.setIsDefault(false);
//        cartCheckOut001Vo.setAddTime(address.getAddTime());
//        cartCheckOut001Vo.setUpdateTime(address.getUpdateTime());
//        cartCheckOut001Vo.setDeleted(false);
//
//        //6.根据userId,market_order_goods表中查询对应信息；将查询数据封装到CartCheckOut002Vo中
//             //改进：根据用户id，查询到订单id;根据订单id，在market_order_goods中查询到批量的订单中商品的信息
//
//        //6.1根据用户id，查询到订单id;(不合理，但是暂时没办法；此处默认：一个用户只能下一个订单，一个用户id和一个订单id，一一对应)
//        OrderExample orderExample = new OrderExample();
//        OrderExample.Criteria criteria2 = orderExample.createCriteria();
//        criteria2.andUserIdEqualTo(id);
//        List<Order> orders = orderMapper.selectByExample(orderExample);
//        Integer orderId = orders.get(0).getId();   //获取到orderId
//
//        //6.2根据订单id，在market_order_goods中查询到批量的订单中商品的信息----------》根据用户id，去购物车查询，批量信息
//        ArrayList<CartCheckOut002Vo> cartCheckOut002Vos = new ArrayList<>();
////        OrderGoodsExample example1 = new OrderGoodsExample();
////        OrderGoodsExample.Criteria criteria1 = example1.createCriteria();
////        criteria1.andOrderIdEqualTo(orderId);
//        CartExample example1 = new CartExample();
//        CartExample.Criteria criteria1 = example1.createCriteria();
//        criteria1.andUserIdEqualTo(id);
//
////        List<OrderGoods> orderGoods = orderGoodsMapper.selectByExample(example1);
//        List<Cart> carts1 = cartMapper.selectByExample(example1);
//        for (Cart cart : carts1) {
//            CartCheckOut002Vo cartCheckOut002Vo = new CartCheckOut002Vo();
//            cartCheckOut002Vo.setId(1);
//            cartCheckOut002Vo.setAddTime(cart.getAddTime());
//            cartCheckOut002Vo.setChecked(true);
//            cartCheckOut002Vo.setDeleted(false);
//            cartCheckOut002Vo.setGoodsId(cart.getGoodsId());
//            cartCheckOut002Vo.setGoodsName(cart.getGoodsName());
//            cartCheckOut002Vo.setGoodsSn(cart.getGoodsSn());
//            cartCheckOut002Vo.setNumber(cart.getNumber().intValue());
//            cartCheckOut002Vo.setPicUrl(cart.getPicUrl());
//            cartCheckOut002Vo.setPrice(cart.getPrice().doubleValue());
//            cartCheckOut002Vo.setProductId(cart.getProductId());
////            cartCheckOut002Vo.setSpecifications(orderGood.getSpecifications());
//            cartCheckOut002Vo.setUpdateTime(cart.getUpdateTime());
//            cartCheckOut002Vo.setUserId(id);
//
//            cartCheckOut002Vos.add(cartCheckOut002Vo);
//        }
//
//
//        //7.将上述所有信息，封装到CartCheckOutVo中
//        CartCheckOutVo cartCheckOutVo = new CartCheckOutVo();
//        cartCheckOutVo.setCheckedAddress(cartCheckOut001Vo);
//        cartCheckOutVo.setCheckedGoodsList(cartCheckOut002Vos);
//        cartCheckOutVo.setActualPrice(actualPrice);
//        cartCheckOutVo.setOrderTotalPrice(orderTotalPrice);
//        cartCheckOutVo.setGrouponRulesId(0);
//        cartCheckOutVo.setGrouponPrice(0);
//        cartCheckOutVo.setCartId(cartCheckoutBo.getCartId());
//        cartCheckOutVo.setUserCouponId(cartCheckoutBo.getUserCouponId());
//        cartCheckOutVo.setCouponId(cartCheckoutBo.getCouponId());
//        cartCheckOutVo.setAddressId(cartCheckoutBo.getAddressId());
//        cartCheckOutVo.setGoodsTotalPrice(goodsTotalPrice);
//        cartCheckOutVo.setCouponPrice(couponPrice);
//        //根据userid在market_coupon_user中进行查询，总的优惠券个数
//        CouponUserExample couponexample = new CouponUserExample();
//        CouponUserExample.Criteria criteria3 = couponexample.createCriteria();
//        criteria3.andUserIdEqualTo(id);
//        List<CouponUser> couponUsers = couponUserMapper.selectByExample(couponexample);
//        Integer couponNum=0;
//        for (CouponUser user : couponUsers) {
//            couponNum++;
//        }
//
//        cartCheckOutVo.setAvailableCouponLength(couponNum);//**************************优惠券的数量
//        cartCheckOutVo.setFreightPrice(freightPrice);
//        return cartCheckOutVo;
//    }


    /**
     * 根据用户id,market_cart查询对应的商品总数和总价格（计算）；--->封装到cartTotal对象中
     * 根据用户id，market_cart查询所有对应信息，封装到cartList list中；（从carts中获取用户信息）
     *
     * @param example
     * @return
     */
    public CartIndexTransferVo transferFZ(CartExample example) {
        List<Cart> carts = cartMapper.selectByExample(example);   //查询条件设置---->cart中涉及了数据库：jason数组--->cart中List[String]的输出映射
        Integer goodsCount = 0;
        Integer checkedGoodsCount = 0;
        Double goodsAmount = 0.0;
        Double checkedGoodsAmount = 0.0;

        for (Cart cart : carts) {   //提取查询结果：计算商品价格&总数
            //商品总数
            goodsCount += cart.getNumber();
            checkedGoodsCount += cart.getNumber();

            //商品总价格
            goodsAmount += cart.getNumber() * cart.getPrice().doubleValue();
            checkedGoodsAmount += cart.getNumber() * cart.getPrice().doubleValue();
        }
        CartTotalDTO total = new CartTotalDTO();    //将商品总价格&商品总数，封装到CartTotalDTO
        total.setCheckedGoodsAmount(checkedGoodsAmount);
        total.setCheckedGoodsCount(checkedGoodsCount);
        total.setGoodsAmount(goodsAmount);
        total.setGoodsCount(goodsCount);

        //2.根据用户id，market_cart查询所有对应信息，封装到cartList list中；（从carts中获取用户信息）
        ArrayList<CartListDTO> cartListDTOS = new ArrayList<>();
        for (Cart cart : carts) {
            CartListDTO cartListDTO = new CartListDTO();
            cartListDTO.setId(cart.getId());
            cartListDTO.setUserId(cart.getUserId());
            cartListDTO.setGoodsId(cart.getGoodsId());
            cartListDTO.setGoodsSn(cart.getGoodsSn());
            cartListDTO.setGoodsName(cart.getGoodsName());
            cartListDTO.setProductId(cart.getProductId());
            cartListDTO.setPrice(cart.getPrice().doubleValue());
            cartListDTO.setNumber(cart.getNumber());
            cartListDTO.setSpecifications(cart.getSpecifications());  //cart内部进行转化，后续也需要typehandler处理
            cartListDTO.setChecked(cart.getChecked());
            cartListDTO.setPicUrl(cart.getPicUrl());

            SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            cartListDTO.setAddTime(pattern.format(cart.getAddTime()));   //date---->string(此处的转化，如果有问题，需要进一步思考)
            cartListDTO.setUpdateTime(pattern.format(cart.getUpdateTime()));

            cartListDTO.setDeleted(cart.getDeleted());
            cartListDTOS.add(cartListDTO);
        }

        //3.CartIndexTransferVo封装查询到的CartListDTO和CartTotalDTO，并返回
        CartIndexTransferVo cartIndexTransferVo = new CartIndexTransferVo();
        cartIndexTransferVo.setCartList(cartListDTOS);
        cartIndexTransferVo.setCartTotal(total);

        return cartIndexTransferVo;
    }


    /**
     *  根据用户id,获取购物车中商品的总个数
     *
     * @param userId
     * @return
     */
    @Override
    public int selectGoodsNum(Integer userId) {
        CartExample cartExample = new CartExample();
        CartExample.Criteria cartExampleCriteria = cartExample.createCriteria();
        if(userId != null){
            cartExampleCriteria.andUserIdEqualTo(userId);
        }
        List<Cart> cartList = cartMapper.selectByExample(cartExample);
        int cartGoodsNum = 0;
        for (Cart cart : cartList) {
            cartGoodsNum += cart.getNumber();
        }
        return cartGoodsNum;
    }
}
